C & C++ Multimedia Cyber Classroom

home *** CD-ROM | disk | FTP | other *** search

/ C & C++ Multimedia Cyber Classroom / C and C++ Multimedia Cyber Classroom (Prentice Hall) (1998).iso / cpphtp2 / cpphtp2.jar / chpt_07.gml < prev next >

Wrap

Text File | 1998-03-03 | 106KB | 2,561 lines

<html> <chapter> <section type=Popup name=Quotes title="Quotes"> <page> But what, to serve our private ends, Forbids the cheating of our friends? Charles Churchill </page> <page> Instead of this absurd division into sexes they ought to class people as static and dynamic. Evelyn Waugh </page> <page> This above all: to thine own self be true. William Shakespeare, Hamlet </page> <page> Have no friends not equal to yourself. Confucius </page> </section> <section type=Popup name=Answers title="Answers"> <page pagename="Answers 7.1"> Answers 7.1 a) Member initializer. b) friend. c) new, pointer. d) initialized. e) static. f) this. g) const. h) default constructor. i) non-static. j) before. <foreign name="exercises" url="^Exercises::c:s0p0"> </page> <page pagename="Answers 7.1"> k) delete. <foreign name="exercises" url="^Exercises::c:s0p0"> </page> <page pagename="Answers 7.2"> Answers 7.2 a) Error: The class definition for Example has two errors. The first occurs in function getIncrementedData. The function is declared const, but it modifies the object. Correction: To correct the first error, remove the const keyword from the definition of getIncrementedData. Error: The second error occurs in function getCount. This function is declared static, so it is not allowed to access any non-static member of the class. Correction: To correct the second error, remove the output line from the definition of getCount. <foreign name="exercises" url="^Exercises::c:s0p2"> </page> <page pagename="Answers 7.2"> b) Error: Memory dynamically allocated by new is deleted by the C Standard Library function free. Correction: Use C++'s delete operator to reclaim the memory. C-style dynamic memory allocation should not be mixed with C++'s new and delete operators. <foreign name="exercises" url="^Exercises::c:s0p2"> </page> <page pagename="Answer 7.7"> Answer 7.7 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P7_07.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p8"> </page> <page pagename="Answer 7.8"> Answer 7.8 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P7_08.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p9"> </page> </section> <section type=Body name=Default title="7 Classes: Part II"> <page> 7 Classes: Part II<hr> <a href="#s1p0">7.1<spacer width=20 height=1>Introduction</a> <a href="#s2p0">7.2<spacer width=20 height=1>const (Constant) Objects and const Member Functions</a> <a href="#s3p0">7.3<spacer width=20 height=1>Composition: Objects as Members of Classes</a> <a href="#s4p0">7.4<spacer width=20 height=1>friend Functions and friend Classes</a> <a href="#s5p0">7.5<spacer width=20 height=1>Using the this Pointer</a> <a href="#s6p0">7.6<spacer width=20 height=1>Dynamic Memory Allocation with Operators new and delete </a> <a href="#s7p0">7.7<spacer width=20 height=1>static Class Members</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> <page> <a href="#s8p0">7.8<spacer width=20 height=1>Data Abstraction and Information Hiding</a> <a href="#s9p0">7.9<spacer width=20 height=1>Container Classes and Iterators</a> <a href="#s10p0">7.10<spacer width=20 height=1>Proxy Classes</a> <a href="#s11p0">7.11<spacer width=20 height=1>Thinking About Objects: Using Composition and Dynamic Object Management in the Elevator Simulator</a> <a href="#s12p0">7.12<spacer width=20 height=1>Elevator Laboratory Assignment 6</a> <a href="#s13p0">7.13<spacer width=20 height=1>Summary </a> <a href="^Terminology::c:s0p0">Terminology</a> <a href="^Illustration::c:s0p0">Figures</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> </section> <section type=Body name=Default title="7.1 Introduction"> <page> 7.1 Introduction<hr> In this chapter we continue our study of classes and data abstraction. We discuss many more advanced topics and lay the groundwork for the discussion of classes and operator overloading in Chapter 8. The discussion in Chapters 6 through 8 encourages programmers to use objects, what we call object-based programming (OBP). Then, Chapters 9 and 10 introduce inheritance and polymorphism--the techniques of truly object-oriented programming (OOP). In this and several subsequent chapters, we use the C-style strings we introduced in Chapter 5. This will </page> <page> help the reader master the complex topic of C pointers and prepare for the professional world in which the reader will see a great deal of C legacy code that has been put in place over the last two decades. In Chapter 19, "Class string," we discuss the new style of strings, namely strings as full-fledged class objects. Thus, the reader will become familiar with the two most prevalent methods of creating and manipulating strings in C++. </page> </section> <section type=Body name=Default title="7.2 const (Constant) Objects and const Member Functions"> <page> 7.2 const (Constant) Objects and const Member Functions<hr> <a href="^Engineer::c:s0p0"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>We have emphasized the principle of least privilege as one of the most fundamental principles of good software engineering. Let us see how this principle applies to objects. <spacer width=16 height=1> <a href="^Engineer::c:s0p1"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>Some objects need to be modifiable and some do not. The programmer may use the keyword const to specify that an object is not modifiable, and that any attempt to modify <a href="^Perform::c:s0p0"> <img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>the object is a syntax error. For example, <pre> const Time noon( 12, 0, 0 ); </pre> </page> <page> declares a const object noon of class Time and initializes it to 12 noon. <spacer width=16 height=1>C++ <a href="^Engineer::c:s0p2"> <img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>compilers disallow any member function calls for const objects unless the member functions themselves are also declared const. This is true even for get member functions that do not modify the object. Member functions <a href="^Errors::c:s0p0"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>declared const cannot modify the object--the compiler <a href="^Errors::c:s0p1"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>disallows this. <spacer width=16 height=1>A function is specified as const both in its prototype and <a href="^Errors::c:s0p2"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>in its definition by inserting the keyword const after the function's parameter list, and, in the case of the function definition, before the left brace that begins </page> <page> the function body. For example, the following member function of class A <pre> int A::getValue() const { return privateDataMember }; </pre> simply returns the value of one of the object's data members, and is appropriately declared const. <spacer width=16 height=1>An interesting problem arises here for constructors and destructors, each of which often needs to <a href="^Errors::c:s0p3"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>modify objects. The const declaration is not required for constructors and destructors of const objects. A constructor must be allowed to modify an object so that the object can be initialized properly. A destructor must </page> <page> be able to perform its termination housekeeping chores before an object is destroyed. <spacer width=16 height=1>The program of <a href="^Code::c:s0p0"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.1</a> instantiates two Time objects--one <a href="^Practice::c:s0p0"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>non-const object and one <tt>const</tt> object. The program attempts to modify the <tt>const</tt> object noon with non-const member functions setHour (at line 100) and printStandard (at line 106). The program also illustrates the three other combinations of member function calls on objects--a non-const member function on a non-const object (line 98), a <tt>const</tt> member function on a non-const object (line 102) and a const member function on a const object (line 104 and 105). The messages generated by one popular compiler </page> <page> for non-const member functions called on a const object are shown in the output window. <spacer width=16 height=1>Notice that even though a constructor must be a non- const member function, it can still be called for a const object. The definition of the Time constructor at lines 39 and 40 <pre> Time::Time( int hr, int min, int sec ) { setTime( hr, min, sec ); } </pre> shows that the Time constructor calls another non- const member function--setTime--to <a href="^Engineer::c:s0p7"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>perform the initialization of a Time object. Invoking a non-const member function from the constructor call for a <tt>const</tt> object is allowed. </page> <page> Also notice that line 106 (line 21 in the source file) <pre> noon.printStandard(); // non-const const </pre> generates a compiler error even though member function printStandard of class Time does not modify the object on which it is invoked. <spacer width=16 height=1> <a href="^Code::c:s0p1"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.2</a> demonstrates the use of a member initializer to initialize const data member increment of class Increment. The constructor for Increment is modified as follows: <pre> Increment::Increment( int c, int i ) : increment( i ) { count = c; } </pre> </page> <page> The notation : increment( i ) initializes increment to the value i. If multiple member initializers are needed, simply include them in a comma-separated list after the colon. <a href="^Debug::c:s0p0"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>All data members can be initialized using member <a href="^Engineer::c:s0p6"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>initializer syntax, but consts and references must be <a href="^Errors::c:s0p4"> <img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>initialized in this manner. Later in this chapter, we will see that member objects must be initialized this way. In Chapter 9 when we study inheritance, we will see that base class portions of derived classes also must be initialized this way. <spacer width=16 height=1> <a href="^Code::c:s0p2"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.3</a> illustrates the compiler errors issued by one popular C++ compiler for a program that attempts to </page> <page> initialize increment with an assignment statement rather than with a member initializer. Note that the print function at line 24 is declared const. It is <a href="^Engineer::c:s0p9"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>reasonable, yet strange, to label this function const because we will probably never have a const Increment object. <spacer width=16 height=1>C++ provides a new keyword called <tt>mutable</tt> that affects the treatment <a href="^Debug::c:s0p1"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>of const objects in a program. We discuss keyword mutable in Chapter 21. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. An object can be declared const."> An object cannot be declared as const. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Member functions declared const cannot modify the object. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Destructors cannot be declared const. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Constructors cannot be declared const."> Constructors may declared const. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.3 Composition: Objects as Members of Classes"> <page> 7.3 Composition: Objects as Members of Classes<hr> An AlarmClock class object needs to know when it is supposed to sound its alarm, so why not include a Time object as a member of the AlarmClock object? Such a capability is <a href="^Engineer::c:s0p11"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>called composition. A class can have objects of other classes as members. <spacer width=16 height=1>When an object is created, its constructor is called automatically, so we need to specify how arguments are passed to member-object constructors. Member objects are constructed in the order in which they are declared (not in the order they are listed in the constructor's </page> <page> member initializer list) and before their enclosing class objects (sometimes called host objects) are constructed. <spacer width=16 height=1> <a href="^Code::c:s0p3"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.4</a> uses class Employee and class Date to demonstrate objects as members of other objects. Class Employee contains private data members firstName, lastName, birthDate, and hireDate. Members birthDate and hireDate are const objects of class Date which contains private data members month, day and year. The program instantiates an Employee object, and initializes and displays its data members. Note the syntax of the function header in the Employee constructor definition: </page> <page> <pre> Employee::Employee( char *fname, char *lname, int bmonth, int bday, int byear, int hmonth, int hday, int hyear ) : birthDate( bmonth, bday, byear ), hireDate( hmonth, hday, hyear ) </pre> The constructor takes eight arguments (fname, lname, bmonth, bday, byear, hmonth, hday, and hyear). The colon (:) in the header separates the member initializers from the parameter list. The member initializers specify the Employee arguments being passed to the constructors of the member objects. Arguments bmonth, bday, and byear are passed to the birthDate constructor, and arguments hmonth, hday, and hyear </page> <page> are passed to the hireDate constructor. Multiple member initializers are separated by commas. <spacer width=16 height=1>Remember that <tt>const</tt> members and references are also initialized in the member initializer list (in Chapter 9, we will see that base class portions of derived classes are also initialized this way). Class Date and class Employee each include a destructor function that prints a message when a Date object or an Employee object is destroyed, respectively. This enables us to confirm in the program output that objects are constructed from the inside out and destructed in the reverse order from the outside in (i.e., the Date member objects are destroyed after the Employee object that contains them). </page> <page> A member object does not need to be initialized explicitly through a <a href="^Perform::c:s0p2"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>member initializer. If a member initializer is not provided, the member <a href="^Errors::c:s0p5"> <img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>object's default constructor will be called implicitly. Values, if any, established by the default <a href="^Engineer::c:s0p12"> <img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>constructor can be overridden by set functions. <spacer width=16 height=1>Notice the call to Date member function print at line 43. Many member functions of classes in C++ require no arguments. This is because each member function contains an implicit handle (in the form of a pointer) to the object on which it operates. We discuss the implicit pointer--called <tt>this</tt>--in <a href="#s5p0">Section 7.5</a>. </page> <page> In this first version of our Employee class (for ease of programming), we use two 25-character arrays to represent the first and last name of the Employee. These arrays may be a waste of space for names shorter than 24 characters (remember one character in each array is for the terminating null character, '\\0', of the string). Also, names longer than 24 characters must be truncated to fit into these character arrays. Later in this chapter we will present another version of class Employee that dynamically creates the exact amount of space to hold the first and the last name. Also, we could use two string objects to represent the names. Standard library class <tt>string</tt> is presented in detail in Chapter 19. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. A class can have objects of other classes as members. This is known as composition."> A class cannot have objects of other classes as members. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> If a member initializer is not provided for a member object, the member object's default constructor is called implicitly. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> References and const members must be initialized in the member initializer list. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.4 friend Functions and friend Classes"> <page> 7.4 friend Functions and friend Classes<hr> A friend function of a <a href="^Engineer::c:s0p13"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>class is defined outside that class's scope, yet has the right to <a href="^Engineer::c:s0p14"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>access private (and as we will see in Chapter 9, "Inheritance," protected) members of the class. A function or an entire class may be declared to be a friend of another class. <spacer width=16 height=1>Using <tt>friend</tt> <a href="^Engineer::c:s0p15"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>functions enhances performance. A mechanical example is shown here of how a friend function works. Later in the book, friend functions are used to overload operators for use with class objects and to create iterator classes. Objects of an iterator class are used to successively select items or perform an </page> <page> operation on items in a container class (see <a href="#s9p0">Section 7.9</a>) object. Objects of container classes are capable of storing items. Using friends is often appropriate when a member function cannot be used for certain operations as we will see in Chapter 8, "Operator Overloading." <spacer width=16 height=1>To declare a function as a friend of a class, precede the function prototype in the class definition with the keyword friend. <a href="^Practice::c:s0p1"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>To declare class ClassTwo as a friend of class ClassOne place a declaration of the form <pre> friend class ClassTwo; </pre> in the definition of class ClassOne. </page> <page> Friendship is granted, not taken, i.e., for class B to be a friend of class A, class A must explicitly declare that class B is its friend. Also, friendship is neither symmetric nor transitive, i.e., if class A is a friend of class B, and class B is a friend of class C, you cannot infer that class B is a friend of class A (again, friendship is not symmetric), that class C is a friend of class B, or that class A is a friend of class C (again, friendship is not transitive). <spacer width=16 height=1> <a href="^Code::c:s0p4"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.5</a> demonstrates the declaration and use of <tt>friend</tt> function setX for setting the private data member x of class count. Note that the friend declaration appears first (by convention) in the class </page> <page> declaration, even before public member functions are declared. The program of <a href="^Code::c:s0p5"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.6</a> demonstrates the messages produced by the compiler when non-friend function cannotSetX is called to modify private data member x. <a href="^Code::c:s0p4"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figures 7.5</a> and <a href="^Code::c:s0p5"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>7.6</a> are intended to introduce the "mechanics" of using friend functions-- practical examples of using friend functions appear in forthcoming chapters. <spacer width=16 height=1>Note that function setX (line 17) is a C-style, stand- alone function--it is not a member function of class Count. For this reason, when setX is invoked for object counter we use the statement at line 29 <pre> setX( counter, 8 ); // set x with a friend </pre> </page> <page> that takes counter as an <a href="^Engineer::c:s0p16"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>argument rather than using a handle (such as the name of the object) to call the function as in <pre> counter.setX( 8 ); </pre> It is possible to specify overloaded functions as friends of a class. Each overloaded function intended to be a friend must be explicitly declared in the class definition as a friend of the class. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> A friend function of a class can access all private data of the class. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Friendship must be explicitly granted by a specific class."> Friendship is transitive. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> A function or class may be designated a friend of another class. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.5 Using the this Pointer"> <page> 7.5 Using the this Pointer<hr> Every object has access to its own address through a pointer called this. An object's this pointer is not part of the object itself--i.e., the this pointer is not reflected in the result of a <tt>sizeof</tt> operation on the object. Rather, the this pointer is passed into the object (by the compiler) as an implicit first argument on every non- static member function call to the object (static members are discussed in <a href="#s7p0">Section 7.7</a>). <spacer width=16 height=1>The this pointer is implicitly used to reference both the data members and member functions of an object; it can also be used explicitly. The type of the this pointer </page> <page> depends on the type of the object and whether the member function in which this is used is declared const. In a non-constant member function of class Employee, the this <a href="^Perform::c:s0p4"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>pointer has type Employee * const (a constant pointer to an Employee object). In a constant member function of class Employee, the this pointer has type const Employee * const (a constant pointer to an Employee object that is constant). <spacer width=16 height=1>For now, we show a simple example of using the this pointer explicitly; later in this chapter and in Chapter 8, we show some substantial and subtle examples of using this. Every non-static member function has access to </page> <page> the this pointer to the object for which the member is being invoked. <spacer width=16 height=1> <a href="^Code::c:s0p6"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.7</a> demonstrates the explicit use of the this pointer to enable a member function of class Test to print the private data x of a Test object. <spacer width=16 height=1>For illustration purposes, the print member function in <a href="^Code::c:s0p6"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.7</a> first prints x directly. Then, print uses two different notations for accessing x through the this pointer--the arrow operator (->) off the this pointer and the dot operator (.) off the dereferenced this pointer. <spacer width=16 height=1>Note the parentheses around *this when used with the dot member selection operator (.). The parentheses are needed because the dot operator has higher precedence </page> <page> than the * operator. Without the parentheses, the expression <pre> *this.x </pre> would be evaluated as if it were parenthesized as follows: <pre> *( this.x ) </pre> which is a <a href="^Errors::c:s0p6"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>syntax error because the dot operator cannot be used with a pointer. <spacer width=16 height=1>One interesting use of the this pointer is to prevent an object from being assigned to itself. As we will see in Chapter 8, "Operator Overloading," self-assignment </page> <page> can cause serious errors when the objects contain pointers to dynamically allocated storage. <spacer width=16 height=1>Another use of the this pointer is in enabling cascaded member function calls. <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 7.8</a> illustrates returning a reference to a Time object to enable member function calls of class Time to be cascaded. Member functions setTime, setHour, setMinute, and setSecond each return *this with a return type of Time &. <spacer width=16 height=1>Why does the technique of returning *this as a reference work? The dot operator (.) associates from left to right, so the expression <pre> t.setHour( 18 ).setMinute( 30 ).setSecond( 22 ); </pre> </page> <page> first evaluates t.setHour( 18 ) then returns a reference to object t as the value of this function call. The remaining expression is then interpreted as <pre> t.setMinute( 30 ).setSecond( 22 ); </pre> The t.setMinute( 30 ) call executes and returns the equivalent of t. The remaining expression is interpreted as <pre> t.setSecond( 22 ); </pre> Note the calls <pre> t.setTime( 20, 20, 20 ).printStandard(); </pre> also use the cascading feature. These calls must appear in this order in this expression because printStandard </page> <page> as defined in the class does not return a reference to t. Placing the call to printStandard in the preceding statement before the call to setTime results in a syntax error. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. It is not reflected in the sizeof operation."> The this pointer is reflected in the sizeof operation for an object. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The this pointer is passed as an implicit first argument to a non-static member function by the compiler. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Every object has access to its own address through the this pointer. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.6 Dynamic Memory Allocation with Operators new and delete"> <page> 7.6 Dynamic Memory Allocation with Operators new and delete <hr> The new and delete operators provide a nicer means of performing dynamic memory allocation (for any built- in or user-defined type) than with C's malloc and free function calls. Consider the following code <pre> TypeName *typeNamePtr; </pre> In ANSI C, to dynamically create an object of type TypeName, you would say <pre> typeNamePtr = malloc( sizeof( TypeName ) ); </pre> </page> <page> This requires a function call to malloc and explicit use of the sizeof operator. In versions of C prior to ANSI C, you would also have to cast the pointer returned by malloc with the cast (TypeName *). Function malloc does not provide any method of initializing the allocated block of memory. In C++, you simply write <pre> typeNamePtr = new TypeName; </pre> The new operator automatically creates an object of the proper size, calls the constructor for the object and returns a pointer of the correct type. If new is unable to find space, it returns a 0 pointer in versions of C++ prior to the ANSI/ISO draft standard. [Note: In Chapter 13, we will show you how to deal with new failures in </page> <page> the context of the ANSI/ISO C++ draft standard. In particular, we will show how <tt>new</tt> "throws" an "exception" and we will show how to "catch" that exception and deal with it.] To free the space for this object in C++ you must use the delete operator as follows: <pre> delete typeNamePtr; </pre> C++ allows you to provide an initializer for a newly created object as in: <pre> float *thingPtr = new float ( 3.14159 ); </pre> which initializes a newly created float object to 3.14159. </page> <page> A 10-element integer array can be created and assigned to arrayPtr as follows: <pre> int *arrayPtr = new int[ 10 ]; </pre> This array can be deleted with the statement <pre> delete [] arrayPtr; </pre> As we will see, <a href="^Errors::c:s0p7"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>using new and delete instead of malloc and free offers other benefits as well. In particular, new automatically <a href="^Errors::c:s0p9"> <img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>invokes the constructor, and delete automatically <a href="^Practice::c:s0p2"> <img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>invokes the class's destructor. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Operator new automatically creates an object of the proper size, calls the constructor, and returns a pointer of the proper type. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. 0 is returned."> If new cannot allocate the space for an object, -1 is returned. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Operator delete is used to deallocate the memory allocated by new."> Operator free is used to deallocate memory allocated by new. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. delete does automatically invoke the destructor for an object."> delete does not automatically invoke the destructor for an object. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.7 static Class Members"> <page> 7.7 static Class Members<hr> Each object of a class has its own copy of all the data members of the class. In certain cases only one copy of a variable should be shared by all objects of a class. A <tt>static</tt> class variable is used for these and other reasons. A static class variable represents "class-wide" information. The declaration of a static member begins with the keyword static. <spacer width=16 height=1>Let us motivate the need for static class-wide data with a video game example. Suppose we have a video game with Martians and other space creatures. Each Martian tends to be brave and willing to attack other </page> <page> space creatures when the Martian is aware that there are at least 5 Martians present. If there are fewer than five Martians present, each Martian becomes cowardly. So each Martian needs to know the martianCount. We could endow class Martian with martianCount as a data member. If we do this, then every Martian will have a separate copy of the data member and every time we create a new Martian we will have to update the data member martianCount in every Martian. This wastes space with the redundant copies and wastes time in updating the separate copies. Instead, we declare martianCount to be static. This makes martianCount class-wide data. Every Martian </page> <page> can see the martianCount as if it were a data member of the Martian, but only one copy of the static martianCount is maintained by C++. This saves space. We save time by having the Martian constructor increment the static martianCount. Because there is only one copy, we do not have to increment separate copies of martianCount for each Martian object. <spacer width=16 height=1>Although static <a href="^Perform::c:s0p6"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>data members may seem like global variables, static data members have class scope. static members can be public, private or protected. static data members must be initialized once (and only once) at file scope. A class's public static class members can be accessed through any object of that class, or they can </page> <page> be accessed through the class name using the binary scope resolution operator. A class's private and protected static members must be accessed through public member functions of the class or through friends of the class. A class's <tt>static</tt> members exist even when no objects of that class exist. To access a <tt>public static</tt> class member when no objects of the class exist, simply prefix the class name and the binary scope resolution operator (<tt>::</tt>) to the name of the data member. To access a private or protected static class member when no objects of the class exist, a public static member function must be provided and the function </page> <page> must be called by prefixing its name with the class name and binary scope resolution operator. <spacer width=16 height=1>The program of <a href="^Code::c:s0p8"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.9</a> demonstrates the use of a <tt>private static </tt>data member and a <tt>public static</tt> member function. The data<a href="^Errors::c:s0p11"> <img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>member count is initialized to zero at file scope with the statement <pre> int Employee::count = 0; </pre> Data member count maintains a count of the number of objects of class Employee that have been instantiated. When objects of class Employee exist, member count can be referenced through any member function of an Employee object--in this example, count is referenced by both the constructor and the destructor. </page> <page> When no objects of class Employee exist, member count can still be referenced, but only through a call to <tt>static</tt> member function getCount as follows: <pre> Employee::getCount() </pre> In this example, function getCount is used to determine the number of Employee objects currently instantiated. Note<a href="^Engineer::c:s0p18"> <img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>that when there are no objects instantiated in the program, the Employee::getCount() function call is issued. However, when there are objects instantiated function getCount can be called through one of the objects as shown in the statement at lines 98 and 99 </page> <page> <pre> cout << "Number of employees after instantiation is " << e1Ptr->getCount(); </pre> Note that the calls e2Ptr->getCount() and Employee::getCount() would work in the preceding statement as well. <spacer width=16 height=1>A member function may be declared static if it does not access <a href="^Engineer::c:s0p19"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>non-static class data members and member functions. Unlike non-static member functions, a static member function has no this <a href="^Errors::c:s0p12"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>pointer because static data members and static <a href="^Errors::c:s0p13"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>member functions exist independent of any objects of a class. </page> <page> Lines 94 and 95 use operator new to dynamically allocate two Employee objects. When each Employee object is allocated, its constructor is called. When delete is used at lines 107 and 109 to deallocate the two Employee objects, their <a href="^Practice::c:s0p3"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>destructors are called. <spacer width=16 height=1>Note the use of assert in the Employee constructor function. The assert "macro"--defined in the assert.h header file--tests the value of a condition. If the value of the expression is false, then assert issues an error message and calls function abort (of the general utilities header file--stdlib.h) to terminate program execution. This is a useful debugging tool for testing if a variable has a correct value. In this program, assert determines </page> <page> if the new operator was able to fulfill the request for memory to be allocated dynamically. For example, in the Employee constructor function, the following line (which is also called an assertion) <pre> assert( firstName != 0 ); </pre> tests pointer firstName to determine if it is not equal to 0. If the condition in the preceding assertion is true, the program continues without interruption. If the condition in the preceding assertion is false, an error message containing the line number, the condition being tested, and the file name in which the assertion appears is printed, and the program terminates. The programmer may then concentrate on this area of the code to find the </page> <page> error. In Chapter 13, "Exception Handling," we will provide a better method of dealing with execution time errors. <spacer width=16 height=1>Assertions do not have to be removed from the program when debugging is completed. When assertions are no longer needed for debugging purposes in a program, the line <pre> #define NDEBUG </pre> is inserted at the beginning of the program file. This causes the preprocessor to ignore all assertions instead of the programmer having to delete each assertion manually. </page> <page> Note that the implementations of functions getFirstName and getLastName return to the client of the class constant character pointers. In this implementation, if the client wishes to retain a copy of the first name or last name, the client is responsible for copying the dynamically allocated memory in the Employee object after obtaining the constant character pointer from the object. Note that it is also possible to implement getFirstName and getLastName so the client is required to pass a character array and the size of the array to each function. Then, the functions could copy the first or last name into the character array provided by the client. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> static members are shared by all instances of a class. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> static members can be designated public, protected, or private. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. A class's static members exist from the beginning of program execution. "> A class's static members only exist when an object of the class exists. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.8 Data Abstraction and Information Hiding"> <page> 7.8 Data Abstraction and Information Hiding<hr> Classes normally hide their implementation details from the clients of the classes. This is called information hiding. As an example of information hiding, let us consider a data structure called a stack. <spacer width=16 height=1>Think of a stack in terms of a pile of dishes. When a dish is placed on the pile, it is always placed at the top (referred to as pushing onto the stack), and when a dish is removed from the pile, it is always removed from the top (referred to as popping off the stack). Stacks are known as last-in, first-out (LIFO) data structures--the </page> <page> last item pushed (inserted) on the stack is the first item popped (removed) from the stack. <spacer width=16 height=1>The programmer may create a stack class and hide from its clients the implementation of the stack. Stacks can easily be implemented with arrays (or linked lists; see Chapter 15, "Data Structures"). A client of a stack class need not know how the stack is implemented. The client simply requires that when data items are placed in the stack, the data items will be recalled in last-in, first- out order. Describing the functionality of a class independent of its implementation is called data abstraction and C++ classes define so-called abstract data types (ADTs). Although users may happen to know </page> <page> the details of how a class is implemented, users should not write code that depends on these details. This means that the implementation of a particular class (such as one that implements a stack and its operations of push and pop) can be altered or replaced without affecting the rest of the system, as long as the public interface to that class does not change. <spacer width=16 height=1>The job of a high-level language is to create a view convenient for programmers to use. There is no single accepted standard view--that is one reason why there are so many programming languages. Object-oriented programming in C++ presents yet another view. </page> <page> Most programming languages emphasize actions. In these languages, data exists in support of the actions programs need to take. Data is viewed as being "less interesting" than actions, anyway. Data is "crude." There are only a few built-in data types, and it is difficult for programmers to create their own new data types. <spacer width=16 height=1>This view changes with C++ and the object-oriented style of programming. C++ elevates the importance of data. The primary activity in C++ is creating new data types (i.e., classes) and expressing the interactions among objects of those data types. </page> <page> To move in this direction, the programming-languages community needed to formalize some notions about data. The formalization we consider is the notion of abstract data types (ADTs). ADTs receive as much attention today as structured programming did over the last two decades. ADTs do not replace structured programming. Rather, they provide an additional formalization that can further improve the program development process. <spacer width=16 height=1>What is an abstract data type? Consider the built-in type int. What comes to mind is the notion of an integer in mathematics, but int on a computer is not precisely what an integer is in mathematics. In particular, </page> <page> computer ints are normally quite limited in size. For example, int on a 32-bit machine may be limited approximately to the range 2 billion to +2 billion. If the result of a calculation falls outside this range, an "overflow" error occurs and the machine responds in some machine-dependent manner, including the possibility of "quietly" producing an incorrect result. Mathematical integers do not have this problem. So the notion of a computer int is really only an approximation to the notion of a real-world integer. The same is true with float. <spacer width=16 height=1>Even char is an approximation; char values are normally 8-bit patterns of ones and zeros; these patterns </page> <page> look nothing like the characters they represent such as a capital Z, a lowercase z, a dollar sign ($), a digit (5), and so on. Values of type char on most computers are quite limited compared to the range of real-world characters. The 7-bit ASCII character set provides for 128 different character values. This is completely inadequate for representing languages such as Japanese and Chinese that require thousands of characters. <spacer width=16 height=1>The point is that even the built-in data types provided with programming languages like C++ are really only approximations or models of real-world concepts and behaviors. We have taken int for granted until this point, but now you have a new perspective to consider. </page> <page> Types like int, float, char and others are all examples of abstract data types. They are essentially ways of representing real-world notions to some satisfactory level of precision within a computer system. <spacer width=16 height=1>An abstract data type actually captures two notions, namely a data representation and the operations that are allowed on that data. For example, the notion of int defines addition, subtraction, multiplication, division, and modulus operations in C++, but division by zero is undefined; and these allowed operations perform in a manner sensitive to machine parameters such as the fixed-word size of the underlying computer system. Another example is the notion of negative integers </page> <page> whose operations and data representation are clear, but the operation of taking the square root of a negative integer is undefined. In C++, the programmer uses classes to implement abstract data types. We create our own stack class in Chapter 12, "Templates," and we study the standard library stack class in Chapter 20, "Standard Template Library (STL)." </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Information hiding is a process by which a class's data implementation is hidden from the clients of the class. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The primary activity in C++ is creating objects from abstract data types and expressing interactions between those objects. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> <page pagename="7.8.1 Example: Array Abstract Data Type"> 7.8.1 Example: Array Abstract Data Type We discussed arrays in Chapter 4. An array is not much more than a pointer and some space. This primitive capability is acceptable for performing array operations if the programmer is cautious and undemanding. There are many operations that would be nice to perform with arrays, but that are not built into <a href="^Engineer::c:s0p20"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>C++. With C++ classes, the programmer can develop an array ADT that is preferable to "raw" arrays. The array class can provide many helpful new capabilities such as <indent width=8 delay>* Subscript range checking.</indent> <indent width=8 delay>* An arbitrary range of subscripts instead of having to start with 0.</indent> </page> <page pagename="7.8.1 Example: Array Abstract Data Type"> <indent width=8 delay>* Array assignment.</indent> <indent width=8 delay>* Array comparison.</indent> <indent width=8 delay>* Array input/output.</indent> <indent width=8 delay>* Arrays that know their sizes.</indent> We create our own array class in Chapter 8, "Operator Overloading," and we study the standard library class (called <tt>vector</tt>) in Chapter 20. <spacer width=16 height=1>C++ has a small set of built-in types. Classes extend the base programming language. <spacer width=16 height=1>New classes created in C++ environments can be proprietary to an individual, to small groups, or to companies. Classes can also be placed in standard class libraries intended for wide distribution. This does not </page> <page pagename="7.8.1 Example: Array Abstract Data Type"> necessarily promote standards although de facto standards are emerging. The full value of C++ will be realized only when substantial and standardized class libraries become widely available. In the United States, such standardization is proceeding through ANSI, the American National Standards Institute. ANSI and ISO (the International Standards Organization) are currently developing a standard version of C++ which, at the time of this writing, is close to final approval. The reader who learns C++ and object-oriented programming will be ready to take advantage of the new kinds of rapid, component-oriented software development made possible with increasingly abundant and rich libraries. </page> <page pagename="7.8.2 Example: String Abstract Data Type"> 7.8.2 Example: String Abstract Data Type C++ is an intentionally sparse language that provides programmers with only the raw capabilities needed to build a broad range of systems. The language is designed to minimize performance burdens. C++ is appropriate for both applications programming and systems programming--the latter places extraordinary performance demands on programs. Certainly, it would have been possible to include a string data type among C++'s built-in data types. Instead, the language was designed to include mechanisms for creating and implementing string abstract data types through classes. We will develop our own string ADT in Chapter 8. The </page> <page pagename="7.8.2 Example: String Abstract Data Type"> ANSI/ISO draft standard includes a <tt>string</tt> class that we discuss in detail in Chapter 19. </page> <page pagename="7.8.3 Example: Queue Abstract Data Type"> 7.8.3 Example: Queue Abstract Data Type Each of us stands in line from time to time. A waiting line is also called a queue. We wait in line at the supermarket checkout counter, we wait in line to get gasoline, we wait in line to board a bus, we wait in line to pay a toll on the highway, and students know all too well about waiting in line during registration to get the courses they want. Computer systems use many waiting lines internally, so we need to write programs that simulate what queues are and do. <spacer width=16 height=1>A queue is a good example of an abstract data type. A queue offers well-understood behavior to its clients. Clients put things in a queue one at a time--using an </page> <page pagename="7.8.3 Example: Queue Abstract Data Type"> enqueue operation, and the clients get those things back one at a time on demand--using a dequeue operation. Conceptually, a queue can become infinitely long. A real queue, of course, is finite. Items are returned from a queue in first-in, first-out (FIFO) order--the first item inserted in the queue is the first item removed from the queue. <spacer width=16 height=1>The queue hides an internal data representation that somehow keeps track of the items currently waiting in line, and it offers a set of operations to its clients, namely enqueue and dequeue. The clients are not concerned about the implementation of the queue. Clients merely want the queue to operate "as </page> <page pagename="7.8.3 Example: Queue Abstract Data Type"> advertised." When a client enqueues a new item, the queue should accept that item and place it internally in some kind of first-in, first-out data structure. When the client wants the next item from the front of the queue, the queue should remove the item from its internal representation and should deliver the item to the outside world (i.e., to the client of the queue) in FIFO order, i.e., the item that has been in the queue the longest should be the next one returned by the next dequeue operation. <spacer width=16 height=1>The queue ADT guarantees the integrity of its internal data structure. Clients may not manipulate this data structure directly. Only the queue ADT has access to its </page> <page pagename="7.8.3 Example: Queue Abstract Data Type"> internal data. Clients may cause only allowable operations to be performed on the data representation; operations not provided in the ADT's public interface are rejected by the ADT in some appropriate manner. This could mean issuing an error message, terminating execution, or simply ignoring the operation request. <spacer width=16 height=1>We create our own queue class in Chapter 15, "Data Structures," and we study the standard library <tt>queue</tt> class in Chapter 20. </page> </section> <section type=Body name=Default title="7.9 Container Classes and Iterators"> <page> 7.9 Container Classes and Iterators<hr> Among the most popular types of classes are container classes (also called collection classes), i.e., classes designed to hold collections of objects. Container classes commonly provide services such as insertion, deletion, searching, sorting, testing an item for membership in the class, and the like. Arrays, stacks, queues, trees and linked lists are examples of container classes; we studied arrays in Chapter 4 and we will study each of these other data structures in Chapters 15 and 20. </page> <page> It is common to associate iterator objects--or more simply iterators--with container classes. An iterator is an object that returns the next item of a collection (or performs some action on the next item of a collection). Once an iterator for a class has been written, obtaining the next element from the class can be expressed simply. Iterators are normally written as <tt>friends</tt> of the classes for performance reasons; this enables iterators to have direct access to the private data of the classes through which they iterate. Just as a book being shared by several people could have several bookmarks in it at once, a container class can have several iterators operating on it at once. Each iterator maintains its own </page> <page> "position" information. We will discuss containers and iterators in great detail in Chapter 20, "Standard Template Library (STL)." </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Container classes are classes designed to hold collections of objects. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. An iterator is an object that is used to access elements of a container."> An iterator is a repetition structure used to execute statements in a program multiple times. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Iterators are normally implemented as friends. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.10 Proxy Classes"> <page> 7.10 Proxy Classes<hr> It is desirable to hide the implementation details of a class to prevent access to proprietary information (including private data) and proprietary program logic in a class. Providing clients of your class with a proxy class that knows only the public interface to your class enables the clients to use your class's services without giving the client access to your class's implementation details. <spacer width=16 height=1>Implementing a proxy class requires several steps (<a href="^Code::c:s0p9"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>). First, we create the class definition and implementation files for the class whose private data </page> <page> we would like to hide. Our example class, which we call Implementation, is shown in <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, part 1. The proxy class Interface is shown in <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, parts 2 and 3, and the test program and output are shown in <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, part 4. <spacer width=16 height=1>Class Implementation ( <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, part 1 of 4) provides a single private data member called value (this is the data we would like to hide from the client), a constructor to initialize value, and functions setValue and getValue. <spacer width=16 height=1>We create a proxy class definition with an identical public interface to that of class Implementation. The only private member of the proxy class is a pointer to </page> <page> an object of class Implementation. Using a pointer in this manner allows us to hide the implementation details of class Implementation from the client. <spacer width=16 height=1>Class Interface in part 2 of <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a> is the proxy class for class <tt>Implementation</tt>. Notice that the only mention in class <tt>Interface </tt>of the proprietary class Implementation is in the pointer declaration (line 23). When a class definition (such as class Interface) uses only a pointer to another class (such as to class Implementation), the class header file for that other class (which would ordinarily reveal the private data of that class) is not required to be included with #include. You can simply declare that other class as a data type </page> <page> with a forward class declaration (line 15) before the type is used in the file. <spacer width=16 height=1>The implementation file containing the member functions for proxy class Interface (<a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, part 3) is the only file that includes the header file <tt>implementation.h </tt>containing class Implementation The file interface.cpp (<a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a>, part 3) is provided to the client as a precompiled object file along with the header file interface.h that includes the function prototypes of the services provided by the proxy class. Because file interface.cpp is made available to the client only as compiled object code, the client is not </page> <page> able to see the interactions between the proxy class and the proprietary class. <spacer width=16 height=1>The program in part 4 of<a href="^Code::c:s0p9"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.10</a> tests class Interface. Notice that only the header file for class Interface is included in main--there is no mention of the existence of a separate class called Implementation. Thus, the client never sees the private data of class Implementation. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> A Proxy class provides client code with access to the public services of another class without allowing the client to see the data representation of the other class. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. C++ does not contain a proxy keyword. The programmer must follow several steps in order to create a proxy class."> Proxy classes are created with the proxy keyword. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Proxy classes provide a means of hiding implementation details of another class. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="7.11 Thinking About Objects: Using Composition and Dynamic Object Management in the Elevator Simulator"> <page> 7.11 Thinking About Objects: Using Composition and Dynamic Object Management in the Elevator Simulator<hr> In Chapters 2 through 5 you designed your elevator simulator and in Chapter 6 you began programming the simulator. In the body of Chapter 7, we discussed the remaining techniques that you will need to implement a complete, working elevator simulator. In particular, we discussed dynamic object management techniques that enable you to use new and delete to create and destroy objects as necessary as your simulator executes. We also discussed composition, a capability that allows you </page> <page> to create classes that have objects of other classes as members. Composition enables you to create a building class that contains the elevator and the floors, and, in turn, create an elevator class that contains a button, a door and a bell. </page> </section> <section type=Body name=Default title="7.12 Elevator Laboratory Assignment 6"> <page> 7.12 Elevator Laboratory Assignment 6<hr> Each time another person enters the simulator, use operator new to create a Person object to represent that person. Note that new invokes the constructor for the object being created, and, of course, the constructor should properly initialize the object. Each time a person leaves the simulator (after getting off the elevator) use </page> <page> 1. operator delete to destroy the Person object and reclaim the storage occupied by that object; delete invokes the destructor for the object being destroyed. 2. Enumerate the composition relationships among the classes you have implemented for your elevator simulator. Modify the class definitions you created in the "Thinking About Objects" section in Chapter 6 to reflect these composition relationships. 3. Complete the implementation of a working simulator program. We will suggest enhancements to the elevator simulator in subsequent chapters. </page> </section> <section type=Body name=Default title="7.13 Summary"> <page> 7.13 Summary<hr> <indent width=8 delay>* The keyword const specifies that an object is not modifiable.</indent> <indent width=8 delay>* The C++ compiler disallows non-const member function calls on const objects.</indent> <indent width=8 delay>* An attempt by a const member function of a class to modify an object of that class is a syntax error.</indent> <indent width=8 delay>* A function is specified as const both in its declaration and its definition.</indent> <indent width=8 delay>* A const member function may be overloaded with a non-const version. The choice of which overloaded member function to use is made by the compiler based </indent> </page> <page> <indent width=8 delay>* on whether the object has been declared const or not.</indent> <indent width=8 delay>* A const object must be initialized--member initializers must be provided in the constructor of a class when that class contains const data members.</indent> <indent width=8 delay>* Classes can be composed of objects of other classes.</indent> <indent width=8 delay>* Member objects are constructed in the order in which they are listed in the class definition and before their enclosing class objects are constructed.</indent> <indent width=8 delay>* If a member initializer is not provided for a member object, the member object's default constructor is called. </indent> <indent width=8 delay>* A friend function of a class is a function defined outside that class and that has the right to access all mem</indent> </page> <page> <indent width=8 delay>* bers of the class. </indent> <indent width=8 delay>* Friendship declarations can be placed anywhere in the class definition.</indent> <indent width=8 delay>* The this pointer is implicitly used to reference both the member functions and data members of the object.</indent> <indent width=8 delay>* Each object has access to its own address by using the this keyword. </indent> <indent width=8 delay>* The this pointer may be used explicitly.</indent> <indent width=8 delay>* The new operator automatically creates an object of the proper size, runs the object's constructor and returns a pointer of the correct type. To free the space for this object, use the delete operator.</indent> <indent width=8 delay>* An array of objects can be allocated dynamically </indent> </page> <page> <indent width=8 delay>* with new as in</indent> <pre> int *ptr = new int[100]; </pre> which allocates an array of 100 integers and assigns the starting location of the array to ptr. The preceding array of integers can be deleted with the statement <pre> delete [] ptr; </pre> <indent width=8 delay>* A static data member represents "class-wide" information. The declaration of a static member begins with the keyword static.</indent> <indent width=8 delay>* static data members have class scope. </indent> <indent width=8 delay>* static members of a class can be accessed through an object of that class or through the class name using the </indent> </page> <page> <indent width=8 delay>* scope resolution operator (if the member is public).</indent> <indent width=8 delay>* A member function may be declared static if it does not access non-static class members. Unlike non-static member functions, a static member function has no this pointer. This is because static data members and static member functions exist independent of any objects of a class.</indent> <indent width=8 delay>* Classes normally hide their implementation details from the clients of the classes. This is called information hiding. </indent> <indent width=8 delay>* Stacks are known as last-in, first-out (LIFO) data structures--the last item pushed (inserted) on the stack is the first item popped (removed) from the stack. </indent> </page> <page> <indent width=8 delay>* Describing the functionality of a class independent of its implementation is called data abstraction and C++ classes define so-called abstract data types (ADTs). </indent> <indent width=8 delay>* C++ elevates the importance of data. The primary activity in C++ is creating new data types (i.e., classes) and expressing the interactions among objects of those data types.</indent> <indent width=8 delay>* Abstract data types are ways of representing real- world notions to some satisfactory level of precision within a computer system.</indent> <indent width=8 delay>* An abstract data type actually captures two notions, namely a data representation and the operations that are allowed on that data.</indent> </page> <page> <indent width=8 delay>* C++ is an extensible language. Although the language is easy to extend with these new types, the base language itself is not changeable.</indent> <indent width=8 delay>* C++ is an intentionally sparse language that provides programmers with only the raw capabilities needed to build a broad range of systems. The language is designed to minimize performance burdens. </indent> <indent width=8 delay>* Items are returned from a queue in first-in, first-out (FIFO) order--the first item inserted in the queue is the first item removed from the queue.</indent> <indent width=8 delay>* Container classes (also called collection classes) are designed to hold collections of objects. Container classes commonly provide services such as insertion, </indent> </page> <page> <indent width=8 delay>* deletion, searching, sorting, testing an item for membership in the class, and the like.</indent> <indent width=8 delay>* It is common to associate iterator objects--or more simply iterators--with container classes. An iterator is an object that returns the next item of a collection (or performs some action on the next item of a collection). </indent> <indent width=8 delay>* Providing clients of your class with a proxy class that knows only the public interface to your class enables the clients to use your class's services without giving the client access to your class's implementation details.</indent> <indent width=8 delay>* The only private member of the proxy class is a pointer to an object of the class whose private data we would like to hide. </indent> </page> <page> <indent width=8 delay>* When a class definition uses only a pointer to another class, the class header file for that other class (which would ordinarily reveal the private data of that class) is not required to be included with #include. You can simply declare that other class as a data type with a forward class declaration before the type is used in the file.</indent> <indent width=8 delay>* The implementation file containing the member functions for the proxy class is the only file that includes the header file for the class whose private data we would like to hide. </indent> <indent width=8 delay>* The implementation file is provided to the client as a precompiled object file along with the header file that includes the function prototypes of the services pro</indent> </page> <page> <indent width=8 delay>* vided by the proxy class. </indent> </page> </section> <section type=Popup name=Debug title="Testing"> <page> Always declare member functions const if they do not modify the object. This can help eliminate many bugs. </page> <page> Languages like C++ are "moving targets" as they evolve. More keywords are likely to be added to the language. Avoid using "loaded" words like "object" as identifiers. Even though "object" is not currently a keyword </page> <page> in C++, it could become one, so future compiling with new compilers could "break" existing code. </page> </section> <section type=Popup name=Terminology title="Terminology"> <page> A abstract data type <a href="%s8p1"><img src=iicons/bullbib.gif></a> <a href="%s8p15"><img src=iicons/bullbib.gif></a> B binary scope resolution operator (::) <a href="%s7p3"><img src=iicons/bullbib.gif></a> <a href="%s7p3"><img src=iicons/bullbib.gif></a> C cascaded member function calls <a href="%s5p4"><img src=iicons/bullbib.gif></a> composition <a href="%s3p0"><img src=iicons/bullbib.gif></a> <a href="%s11p0"><img src=iicons/bullbib.gif></a> const member function <a href="%s2p0"><img src=iicons/bullbib.gif></a> const object <a href="%s2p0"><img src=iicons/bullbib.gif></a> <a href="%s2p4"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p6"><img src=iicons/bullbib.gif></a> container class <a href="%s4p1"><img src=iicons/bullbib.gif></a> <a href="%s9p0"><img src=iicons/bullbib.gif></a> </page> <page> D data representation <a href="%s8p7"><img src=iicons/bullbib.gif></a> default constructor <a href="%s3p4"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p5"><img src=iicons/bullbib.gif></a> delete <a href="%s6p0"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p7"><img src=iicons/bullbib.gif></a> <a href="%s12p1"><img src=iicons/bullbib.gif></a> delete [] <a href="^Errors::c:s0p9"><img src=iicons/bullbib.gif></a> dequeue <a href="%s8p16"><img src=iicons/bullbib.gif></a> E enqueue <a href="%s8p16"><img src=iicons/bullbib.gif></a> extensible language <a href="^Engineer::c:s0p20"><img src=iicons/bullbib.gif></a> F first-in first-out (FIFO) <a href="%s8p16"><img src=iicons/bullbib.gif></a> </page> <page> forward class declaration <a href="%s10p3"><img src=iicons/bullbib.gif></a> friend <a href="%s4p2"><img src=iicons/bullbib.gif></a> <a href="%s9p1"><img src=iicons/bullbib.gif></a> friend function <a href="%s4p0"><img src=iicons/bullbib.gif></a> H host object <a href="%s3p1"><img src=iicons/bullbib.gif></a> I iterator <a href="%s9p1"><img src=iicons/bullbib.gif></a> L last-in first-out (LIFO) <a href="%s8p0"><img src=iicons/bullbib.gif></a> M member initializer <a href="%s2p7"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p4"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p7"><img src=iicons/bullbib.gif></a> </page> <page> member object's default constructor <a href="%s3p4"><img src=iicons/bullbib.gif></a> <a href="^Perform::c:s0p2"><img src=iicons/bullbib.gif></a> member-access specifier <a href="^Practice::c:s0p1"><img src=iicons/bullbib.gif></a> N new <a href="%s6p0"><img src=iicons/bullbib.gif></a> <a href="%s11p0"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p7"><img src=iicons/bullbib.gif></a> O object-based programming (OBP) <a href="%s1p0"><img src=iicons/bullbib.gif></a> P pop <a href="%s8p2"><img src=iicons/bullbib.gif></a> principle of least privilege <a href="%s2p0"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p0"><img src=iicons/bullbib.gif></a> proxy class <a href="%s10p0"><img src=iicons/bullbib.gif></a> </page> <page> push <a href="%s8p2"><img src=iicons/bullbib.gif></a> Q queue <a href="%s8p15"><img src=iicons/bullbib.gif></a> <a href="%s9p0"><img src=iicons/bullbib.gif></a> S stack <a href="%s8p0"><img src=iicons/bullbib.gif></a> <a href="%s9p0"><img src=iicons/bullbib.gif></a> static data members <a href="^Perform::c:s0p6"><img src=iicons/bullbib.gif></a> static member function <a href="%s7p5"><img src=iicons/bullbib.gif></a> <a href="%s7p6"><img src=iicons/bullbib.gif></a> T this pointer <a href="%s5p0"><img src=iicons/bullbib.gif></a> <a href="%s7p6"><img src=iicons/bullbib.gif></a> </page> </section> <section type=Popup name=Illustration title="Illustrations"> <page> <a href="^Code::c:s0p0">Fig. 7.1</a> Using a Time class with const objects and const member functions. <a href="^Code::c:s0p1">Fig. 7.2 </a> Using a member initializer to initialize a constant of a built-in data type. <a href="^Code::c:s0p2">Fig. 7.3</a> Erroneous attempt to initialize a constant of a built-in data type by assignment. <a href="^Code::c:s0p3">Fig. 7.4</a> Using member-object initializers. <a href="^Code::c:s0p4">Fig. 7.5</a> Friends can access private members of a class. <a href="^Code::c:s0p5">Fig. 7.6</a> Non-friend/non-member functions cannot access private class members. <a href="^Code::c:s0p6">Fig. 7.7</a> Using the this pointer. <a href="^Code::c:s0p7">Fig. 7.8</a> Cascading member function calls. <a href="^Code::c:s0p8">Fig. 7.9</a> Using a static data member to maintain a count of the number of objects of a class. <a href="^Code::c:s0p9">Fig. 7.10</a> Implementing a proxy class. </page> </section> <section type=Popup name=Exercises title="Exercises"> <page pagename="Exercise 7.1"> Exercise 7.1 Fill in the blanks in each of the following: a) ________ syntax is used to initialize constant members of a class. b) A nonmember function must be declared as a ________ of a class to have access to that class's private data members. c) The ________ operator dynamically allocates memory for an object of a specified type and returns a ________ to that type. d) A constant object must be ________; it cannot be modified after it is created. e) A ________ data member represents class-wide information. f) An object's member functions have access to a "self pointer" to the object called the ________ pointer. <foreign name="answers" url="^Answers::c:s0p0"> </page> <page pagename="Exercise 7.1"> g) The keyword ________ specifies that an object or variable is not modifiable after it is initialized. h) If a member initializer is not provided for a member object of a class, the object's ________ is called. i) A member function can be declared static if it does not access ________ class members. j) Member objects are constructed ________ their enclosing class object. k) The ________ operator reclaims memory previously allocated by new. <foreign name="answers" url="^Answers::c:s0p0"> </page> <page pagename="Exercise 7.2"> Exercise 7.2 Find the error(s) in each of the following and explain how to correct it. <pre> a) class Example { public: Example( int y = 10 ) { data = y; } int getIncrementedData() const { return ++data; } static int getCount() { cout << "Data is " << data << endl; return count; } </pre> <foreign name="answers" url="^Answers::c:s0p2"> </page> <page pagename="Exercise 7.2"> <pre> private: </pre> <pre> int data; static int count; }; b) char *string; string = new char[ 20 ]; free( string ); </pre> <foreign name="answers" url="^Answers::c:s0p2"> </page> <page pagename="Exercise 7.3"> Exercise 7.3 Compare and contrast dynamic memory allocation with the C++ operators new and delete, with dynamic memory allocation with the C Standard Library functions malloc and free. </page> <page pagename="Exercise 7.4"> Exercise 7.4 Explain the notion of friendship in C++. Explain the negative aspects of friendship as described in the text. </page> <page pagename="Exercise 7.5"> Exercise 7.5 Can a correct Time class definition include both of the following constructors? If not, explain why not. <pre> Time ( int h = 0, int m = 0, int s = 0 ); Time(); </pre> </page> <page pagename="Exercise 7.6"> Exercise 7.6 What happens when a return type, even void, is specified for a constructor or destructor? </page> <page pagename="Exercise 7.7"> Exercise 7.7 Create a Date class with the following capabilities: a) Output the date in multiple formats such as DDD YYYY MM/DD/YY June 14, 1992 b) Use overloaded constructors to create Date objects initialized with dates of the formats in part (a). c) Create a Date constructor that reads the system date using the standard library functions of the time.h header and sets the Date members. In Chapter 8, we will be able to create operators for testing the equality of two dates and for comparing dates to determine if one date is prior to, or after, another. <foreign name="answers" url="^Answers::c:s0p4"> </page> <page pagename="Exercise 7.8"> Exercise 7.8 Create a SavingsAccount class. Use a static data member to contain the annualInterestRate for each of the savers. Each member of the class contains a private data member savingsBalance indicating the amount the saver currently has on deposit. Provide a calculateMonthlyInterest member function that calculates the monthly interest by multiplying the balance by annualInterestRate divided by 12; this interest should be added to savingsBalance. Provide a static member function modifyInterestRate that sets the static annualInterestRate to a new value. Write a driver program to test class SavingsAccount. Instantiate two different savingsAccount objects, saver1 and saver2, with balances of $2000.00 and $3000.00, respectively. Set annualInterestRate to 3%, then calculate the monthly interest and print the new <foreign name="answers" url="^Answers::c:s0p5"> </page> <page pagename="Exercise 7.8"> balances for each of the savers. Then set the annualInterestRate to 4% and calculate the next month's interest and print the new balances for each of the savers. <foreign name="answers" url="^Answers::c:s0p5"> </page> <page pagename="Exercise7.9"> Exercise7.9 Create a class called IntegerSet. Each object of class IntegerSet can hold integers in the range 0 through 100. A set is represented internally as an array of ones and zeros. Array element a[ i ] is 1 if integer i is in the set. Array element a[ j ] is 0 if integer j is not in the set. The default constructor initializes a set to the so-called "empty set," i.e., a set whose array representation contains all zeros. Provide member functions for the common set operations. For example, provide a unionOfIntegerSets member function that creates a third set which is the set- theoretic union of two existing sets (i.e., an element of the third set's array is set to 1 if that element is 1 in either or both of the existing sets, and an element of the third set's array is set to 0 if that element is 0 in each of the existing sets). </page> <page pagename="Exercise7.9"> Provide an intersectionOfIntegerSets member function that creates a third set which is the set-theoretic intersection of two existing sets (i.e., an element of the third set's array is set to 0 if that element is 0 in either or both of the existing sets, and an element of the third set's array is set to 1 if that element is 1 in each of the existing sets). Provide an insertElement member function that inserts a new integer k into a set (by setting a[k] to 1). Provide a deleteElement member function that deletes integer m (by setting a[m] to 0). Provide a setPrint member function that prints a set as a list of numbers separated by spaces. Print only those elements that are present in the set (i.e., their position in the array has a value of 1). Print --- for an empty set. Provide an isEqualTo member function that determines if two sets are equal. </page> <page pagename="Exercise7.9"> Provide an additional constructor to take five integer arguments which can be used to initialize a set object. If you want to provide fewer than five elements in the set, use default arguments of -1 for the others. Now write a driver program to test your IntegerSet class. Instantiate several IntegerSet objects. Test that all your member functions work properly. </page> <page pagename="Exercise 7.10"> Exercise 7.10 It would be perfectly reasonable for the Time class of <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.8</a> to represent the time internally as the number of seconds since midnight rather than the three integer values hour, minute and second. Clients could use the same public methods and get the same results. Modify the Time class of <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 7.8</a> to implement the Time as the number of seconds since midnight and show that there is no visible change in functionality to the clients of the class. </page> </section> <section type=Popup name=Objective title="Objectives"> <page> <indent width=8 delay>* To be able to create and destroy objects dynamically.</indent> <indent width=8 delay>* To be able to specify const (constant) objects and const member functions.</indent> <indent width=8 delay>* To understand the purpose of friend functions and friend classes.</indent> <indent width=8 delay>* To understand how to use static data members and member functions.</indent> <foreign name="audio" url="~audio/Ch07/07obj.au"> </page> <page> <indent width=8 delay>* To understand the concept of a container class.</indent> <indent width=8 delay>* To understand the notion of iterator classes that walk through the elements of container classes.</indent> <indent width=8 delay>* To understand the use of the this pointer.</indent> </page> </section> <section type=Popup name=Perform title="Performance"> <page> Declaring variables and objects const is not only an effective software engineering practice--it can improve performance as well because today's sophisticated optimizing compilers can perform certain </page> <page> optimizations on constants that cannot be performed on variables. </page> <page> Initialize member objects explicitly through member initializers. This eliminates the overhead of "doubly initializing" member objects--once when the member object's default constructor is called </page> <page> and again when set functions are used to initialize the member object. </page> <page> For reasons of economy of storage, only one copy of each member function exists per class, and this member function is invoked by every object of that class. Each object, on the other hand, has its </page> <page> own copy of the class's data members. </page> <page> Use <tt>static</tt> data members to save storage when a single copy of the data will suffice. </page> </section> <section type=Popup name=Code title="Code Examples"> <page> Figure 7.1 Using a Time class with const objects and const member functions. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_01.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_01.jar"> <foreign name="audio" url="~audio/Ch07/07fig001.au"> </page> <page> Figure 7.2 Using a member initializer to initialize a constant of a built-in data type. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_02.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_02.jar"> <foreign name="audio" url="~audio/Ch07/07fig002.au"> <foreign name="execute" url="!jarexe Run/fig07_02.jar"> </page> <page> Figure 7.3 Erroneous attempt to initialize a constant of a built-in data type by assignment. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_03.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_03.jar"> <foreign name="audio" url="~audio/Ch07/07fig003.au"> </page> <page> Figure 7.4 Using member-object initializers. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_04.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_04.jar"> <foreign name="audio" url="~audio/Ch07/07fig004.au"> <foreign name="execute" url="!jarexe Run/fig07_04.jar"> </page> <page> Figure 7.5 Friends can access private members of a class. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_05.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_05.jar"> <foreign name="audio" url="~audio/Ch07/07fig005.au"> <foreign name="execute" url="!jarexe Run/fig07_05.jar"> </page> <page> Figure 7.6 Non-friend/non-member functions cannot access private class members. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_06.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_06.jar"> <foreign name="audio" url="~audio/Ch07/07fig006.au"> </page> <page> Figure 7.7 Using the this pointer. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_07.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_07.jar"> <foreign name="audio" url="~audio/Ch07/07fig007.au"> <foreign name="execute" url="!jarexe Run/fig07_07.jar"> </page> <page> Figure 7.8 Cascading member function calls. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_08.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_08.jar"> <foreign name="audio" url="~audio/Ch07/07fig008.au"> <foreign name="execute" url="!jarexe Run/fig07_08.jar"> </page> <page> Figure 7.9 Using a static data member to maintain a count of the number of objects of a class. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_09.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_09.jar"> <foreign name="audio" url="~audio/Ch07/07fig009.au"> <foreign name="execute" url="!jarexe Run/fig07_09.jar"> </page> <page> Figure 7.10 Implementing a proxy class. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch07/fig07_10.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig07_10.jar"> <foreign name="execute" url="!jarexe Run/fig07_10.jar"> </page> </section> <section type=Popup name=Practice title="Good Practices"> <page> Declare as const all member functions that do not need to modify the current object so that you can use them on a const object if you need to. </page> <page> Place all friendship declarations first in the class immediately after the class header and do not precede them with any member-access specifier. </page> <page> Because C++ includes C, C++ programs can contain storage created by malloc and deleted by free, and objects created by new and deleted by delete. It is best to use only new and delete. </page> <page> After deleting dynamically allocated memory, set the pointer that referred to that memory to 0. This disconnects the pointer from the previously allocated space on the free store. </page> </section> <section type=Popup name=Engineer title="Engineering"> <page> Declaring an object as const helps enforce the principle of least privilege. Attempts to modify the object are caught at compile time rather than causing execution-time errors. </page> <page> Using const is crucial to proper class design, program design and coding. </page> <page> A const member function can be overloaded with a non- const version. The choice of which overloaded member function to use is automatically made by the compiler based on </page> <page> whether the object is const or not. </page> <page> A const object cannot be modified by assignment so it must be initialized. When a a data member of a class is declared const, a member initializer must be used to provide the constructor with the initial value of the data </page> <page> member for an object of the class. </page> <page> Constant class members (const objects and const "variables") must be initialized with member initializer syntax; assignments are not allowed. </page> <page> A const object cannot be modified by assignment so it must be initialized. When a a data member of a class is declared const, a member initializer must be used to provide the constructor with the initial value of the data </page> <page> member for an object of the class. </page> <page> It is good practice to declare all of a class's member functions that do not modify the object in which they operate as const. Occasionally, this will be an anomaly because you will have no intention of creating </page> <page> const objects of that class. Declaring such member functions const does offer a benefit though. If you inadvertently modify the object in that member function, the compiler will issue a syntax error message. </page> <page> One form of software reusability is composition in which a class has objects of other classes as members. </page> <page> If a class has as a member an object of another class, making that member object public does not violate the encapsulation and hiding of that member object's private members. </page> <page> Even though the prototypes for friend functions appear in the class definition, <tt>friends</tt> are still not member functions. </page> <page> Member access notions of private, protected, and public are not relevant to friendship declarations, so friendship declarations can be placed anywhere in the class definition. </page> <page> Some people in the OOP community feel that "friendship" corrupts information hiding and weakens the value of the object- oriented design approach. </page> <page> Because C++ is a hybrid language, it is common to have a mix of two types of function calls in one program and often back to back--C-like calls that pass primitive data or objects to functions and C++ calls that pass </page> <page> functions (or messages) to objects. </page> <page> Some organizations have in their software engineering standards that all calls to static member functions be made off the class name handle and not off the object handles. </page> <page> A class's static data members and static member functions exist and can be used even if no objects of that class have been instantiated. </page> <page> The programmer is able to create new types through the class mechanism. These new types can be designed to be used as conveniently as the built-in types. Thus, C++ is an extensible language. Although the </page> <page> language is easy to extend with these new types, the base language itself is not changeable. </page> </section> <section type=Popup name=Errors title="Common Errors"> <page> Defining as const a member function that modifies a data member of an object is a syntax error. </page> <page> Defining as const a member function that calls a non-const member function of the class on the same instance of the class is a syntax error. </page> <page> Invoking a non-const member function on a const object is a syntax error. </page> <page> Attempting to declare a constructor or destructor const is a syntax error. </page> <page> Not providing a member initializer for a const data member is a syntax error. </page> <page> Not providing a default constructor for the class of a member object when no member initializer is provided for that member object is a syntax error. </page> <page> Attempting to use the member selection operator (.) with a pointer to an object is a syntax error--the dot member selection operator may only be used with an object or with a reference to an object. </page> <page> Mixing new-and- delete-style dynamic memory allocation with malloc-and-free-style dynamic memory allocation is a logic error: Space created by malloc cannot be freed by delete; objects </page> <page> created by new cannot be deleted by free. </page> <page> Using delete instead of delete [] for arrays can lead to runtime logic errors. To avoid problems, space created as an array should be deleted with the delete [] operator and space created as an individual element should be </page> <page> deleted with the delete operator. </page> <page> It is a syntax error to include keyword static in the definition of a static class variable at file scope. </page> <page> Referring to the this pointer within a static member function is a syntax error. </page> <page> Declaring a static member function const is a syntax error. </page> </section> <section type=Popup name=Portable title="Portability"> <page> This chapter does not contain any Portability tips. </page> </section> <section type=Popup name=AppletPopup title="Applet Examples"> <page> This chapter does not contain any Applet Examples. </page> </section> </chapter> </html> </html>